Large Language Models (LLM) based agents have shown promise in autonomously completing tasks across various domains, e.g., robotics, games, and web navigation. However, these agents typically require elaborate design and expert prompts to solve tasks in specific domains, which limits their adaptability. We introduce AutoManual, a framework enabling LLM agents to autonomously build their understanding through interaction and adapt to new environments. AutoManual categorizes environmental knowledge into diverse rules and optimizes them in an online fashion by two agents: 1) The Planner codes actionable plans based on current rules for interacting with the environment. 2) The Builder updates the rules through a well-structured rule system that facilitates online rule management and essential detail retention. To mitigate hallucinations in managing rules, we introduce \textit{case-conditioned prompting} strategy for the Builder. Finally, the Formulator agent compiles these rules into a comprehensive manual. The self-generated manual can not only improve the adaptability but also guide the planning of smaller LLMs while being human-readable. Given only one simple demonstration, AutoManual significantly improves task success rates, achieving 97.4\% with GPT-4-turbo and 86.2\% with GPT-3.5-turbo on ALFWorld benchmark tasks. The source code will be available soon.

We present POTATO, a task- and languageindependent framework for human-in-the-loop (HITL) learning of rule-based text classifiers using graph-based features. POTATO handles any type of directed graph and supports parsing text into Abstract Meaning Representations (AMR), Universal Dependencies (UD), and 4lang semantic graphs. A streamlit-based user interface allows users to build rule systems from graph patterns, provides real-time evaluation based on ground truth data, and suggests rules by ranking graph features using interpretable machine learning models. Users can also provide patterns over graphs using regular expressions, and POTATO can recommend refinements of such rules. POTATO is applied in projects across domains and languages, including classification tasks on German legal text and English social media data. All components of our system are written in Python, can be installed via pip, and are released under an MIT License on GitHub.

An essential problem space employed by all AI products, this is a very simple introduction to knowledge representation and their applications. In artificial intelligence (AI), knowledge representation is the process of encoding information about the world into a form that computers can use to solve problems. Usually, this means creating formal models of concepts and how they relate to each other. The goal is to make it possible for a computer to draw logical conclusions from a set of facts or hypotheses. No ideal form of knowledge representation exists that applies in all contexts.

In this blog post, I am going to unfold some reasonably technical ideas pertinent most directly to the fourth point in the list: How to make meta-learning work in reality, in the context of a complex multi-algorithm cognitive architecture carrying out a variety of complicated tasks. Dr. Nil Geisweiller has recently written a research blog post describing his current work on "probabilistic inference meta-learning." In his research, he discusses using OpenCog's Probabilistic Logic Networks (PLN) framework as the base-level algorithm for meta-learning, via using pattern-mining and then PLN itself to learn patterns in large sets of PLN inference examples, to learn what sorts of inferences work better in what contexts. This gets at the crux of the meta-learning problem in an OpenCog context; it is about using PLN to help PLN learn how to reason better. This blog post is complementary to Dr. Nil's, in this post I am going to describe some work currently underway to, in effect, fuse various learning/reasoning algorithms now working separately within OpenCog so that they appear as aspects of a single unified learning/reasoning algorithm. This sort of unification provides greater elegance than a situation where there are multiple markedly distinct learning/reasoning algorithms.

The enterprise of developing knowledge-based systems is currently witnessing great growth in popularity. The utility of a well-stocked store of examples and the ability to generate new examples are emphasized. Section 3 displays a wide variety of rule operations in addition to the rule interpreter which applies rules. It includes an argument that systems must be designed to respond well to forces of change. Speech on Artificial Intelligence delivered to the Canadian Information Processing Society, Session '84, Calgary, Alberta An earlier version of this article was published in the Proceedings of the CIPS/Session '84 This article was written while the author was with Rutgers Univcrsity Revision of draft performed at BBN Laboratories Research reported here was supported by NSF Grants Knowledge based systems may be usefully viewed in terms of three interrelated spaces.

In this paper we present a neural-symbolic system for monitoring traces of observations in sofware systems. To this end, we define an algorithm that translates a RuleR rule-based monitoring system (RS) into a rule-based neural network system (RNNS). We then show how the RNNS can perform trace monitoring effectively and analyze its performance, reporting promising preliminary results. Finally, we discuss how network learning could be used within RNNS to embed the system into a framework for iterative verification and model adaptation. It is hoped that a tight integration of verification and adaptation within the neural-symbolic approach will help support the development of self-adapting, self-healing systems.

Videogame design fundamentally involves engineering interactive rule systems: a game designer combines a set of game mechanics such that, when they interact with each other and with the player’s actions, they produce the desired gameplay. Game designers typically prototype these rule systems to understand how they operate. Prototypes range from paper versions, in which a stripped-down form of the game’s rule system is simulated manually, to playable, implemented versions, which can be played by the designer and others to get feedback on gameplay ideas or discover problems. This thesis proposes that a number of the design questions such prototypes try to answer can be answered automatically. The ultimate design questions are mainly subjective: is the game interesting, fun, challenging, balanced, etc.? However, much prototyping gets at these issues indirectly by asking objective questions that help the designer understand how their rule system operates; the objective kinds of questions are amenable to automated reasoning, since they have answers that depend solely on the game’s formal rule system. By answering them automatically, we can speed up the design loop by allowing designers to quickly understand how their rule system is operating, getting much more factual understanding of the system that they can use in their subjective design thinking.

We study the combination of the following already known ideas for showing confluence of unconditional or conditional term rewriting systems into practically more useful confluence criteria for conditional systems: Our syntactical separation into constructor and non-constructor symbols, Huet's introduction and Toyama's generalization of parallel closedness for non-noetherian unconditional systems, the use of shallow confluence for proving confluence of noetherian and non-noetherian conditional systems, the idea that certain kinds of limited confluence can be assumed for checking the fulfilledness or infeasibility of the conditions of conditional critical pairs, and the idea that (when termination is given) only prime superpositions have to be considered and certain normalization restrictions can be applied for the substitutions fulfilling the conditions of conditional critical pairs. Besides combining and improving already known methods, we present the following new ideas and results: We strengthen the criterion for overlay joinable noetherian systems, and, by using the expressiveness of our syntactical separation into constructor and non-constructor symbols, we are able to present criteria for level confluence that are not criteria for shallow confluence actually and also able to weaken the severe requirement of normality (stiffened with left-linearity) in the criteria for shallow confluence of noetherian and non-noetherian conditional systems to the easily satisfied requirement of quasi-normality. Finally, the whole paper may also give a practically useful overview of the syntactical means for showing confluence of conditional term rewriting systems.